Builder Pattern

Builder Pattern က Creational Pattern တစ်ခု ဖြစ်ပါတယ်။ Builder ဆိုသည့် အတိုင်း object ကို ဆောက်သည့် နေရာမှာ အသုံးပြုပါတယ်။

Builder Pattern က object ကို immutable လုပ်ချင်သည့် အခါမှာ အသုံးပြုပါတယ်။ ပုံမှန် အားဖြင့် object ကို immutable လုပ်ချင်သည့် အခါမှာ Consturctor မှာ pass လုပ်ပေးရပါတယ်။

public class Person {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    private String phone;
    private String address;
}

ဒီ Person class မှာ constructor ထည့်သည့် အခါမှာ ၆ ခု လုံး ထည့်မှ ဖြစ်ပါလိမ့်မယ်။

public class Person {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    private String phone;
    private String address;
    
    Person(String firstName,String lastName, int age, String email,String phone,String address) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.email = email;
        this.phone = phone;
        this.address = address;
    }
}

အဲဒီ code ကို သုံးမယ် ဆိုရင်

Person person = new Person("Saturn","God",36,"hello@example.com","Somewhere");

Parameter တွေ အများကြီး pass လုပ်ထားရပြီး readable မဖြစ်ပါဘူး။ တကယ်လို့ နောက်ထပ် parameter ထပ်ပါလာပြီ ဆိုရင် ထပ်ဖြည့် ရပါအုံးမယ်။

Builder Pattern နဲ့ ဆိုရင် အခု လို ရေးလို့ရပါတယ်။

public class Person {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    private String phone;
    private String address;

    private Person(Builder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.email = builder.email;
        this.phone = builder.phone;
        this.address = builder.address;
    }
        
    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", phone='" + phone + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public static class Builder {
        private String firstName;
        private String lastName;
        private int age;
        private String email;
        private String phone;

        public Builder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }
        
        public Builder address(String phone) {
            this.address = address;
            return this;
        }

        public Person build() {
            return new Person(this);
        }
    }
}

Builder class ထည့်ပြီးရင်တော့ Person class ကို build သည့် အခါမှာ အခုလို မျိုး build လုပ်လို့ရပါတယ်။

public static void main(String[] args) {
        Person person = new Builder("John", "Doe")
                .age(30)
                .email("john.doe@example.com")
                .phone("+1234567890")
                .address("john@example.com")
                .build();
        System.out.println(person);
}

Builder Pattern က ရိုးရှင်းပြီး သုံးရတာ လွယ်ကူပါတယ်။ ပုံမှန် အားဖြင့် setter တွေ ထည့်သည့် အခါမှာ class က mutable ဖြစ်သွားပြီး constructor ကနေ pass လုပ်ရင် code က ဖတ်ရတာ ခက်သွားပါတယ်။

Builder pattern က တော့ ရိုးရှင်းလွယ်ကူ ပြီး ထပ်ဖြည့်သည့် အခါမှာလည်း လွယ်လင့် တကူ ဖြည့်နိုင်ပါတယ်။

Pros and Cons

Object တွေကို step-by-step construct လုပ်နိုင်တယ်။

Single Responsibility Principle ကို လိုက်နာထားတယ်။

မကောင်းတာကတော့ properties များလာလေလေ class ကို ပိုပြီး ရှုပ်ထွေးလာစေပါတယ်။